package com.xgq.drink.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.xgq.drink.entity.ChatGroup;
import com.xgq.drink.entity.ChatGroupMember;
import com.xgq.drink.entity.R;
import com.xgq.drink.mapper.ChatGroupMapper;
import com.xgq.drink.mapper.ChatGroupMemberMapper;
import com.xgq.drink.service.IChatGroupService;
import com.xgq.drink.utils.RUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.time.LocalDateTime;
import java.util.List;

/**
 * 聊天群组服务实现类
 */
@Service
@Slf4j
public class ChatGroupServiceImpl extends ServiceImpl<ChatGroupMapper, ChatGroup> implements IChatGroupService {
    
    @Autowired
    private ChatGroupMapper chatGroupMapper;
    
    @Autowired
    private ChatGroupMemberMapper chatGroupMemberMapper;
    
    /**
     * 创建聊天群组
     */
    @Override
    @Transactional
    public R createChatGroup(String ownerId, String groupName, String groupAvatar, String announcement) {
        try {
            if (ownerId == null || groupName == null) {
                return RUtils.fail("群主ID和群组名称不能为空");
            }
            
            // 创建群组
            ChatGroup chatGroup = new ChatGroup();
            chatGroup.setOwnerId(Long.valueOf(ownerId));
            chatGroup.setGroupName(groupName);
            chatGroup.setAvatar(groupAvatar);
            chatGroup.setAnnouncement(announcement);
            chatGroup.setCurrentMemberCount(1); // 初始成员数为1（群主）
            chatGroup.setStatus(1); // 1表示正常
            chatGroup.setCreateTime(LocalDateTime.now());
            chatGroup.setUpdateTime(LocalDateTime.now());
            
            boolean saved = this.save(chatGroup);
            
            if (saved) {
                // 添加群主为成员
                ChatGroupMember member = new ChatGroupMember();
                member.setGroupId(chatGroup.getGroupId());
                member.setUserId(Long.valueOf(ownerId));
                member.setMemberType(1); // 1表示群主
                member.setJoinTime(LocalDateTime.now());
                member.setStatus(1); // 1表示正常
                
                chatGroupMemberMapper.insert(member);
                
                return RUtils.success("创建群组成功", chatGroup);
            } else {
                return RUtils.fail("创建群组失败");
            }
        } catch (Exception e) {
            log.error("创建聊天群组异常", e);
            return RUtils.fail("创建群组异常: " + e.getMessage());
        }
    }

    /**
     * 更新群组信息
     */
    @Override
    public R updateChatGroup(String groupId, String groupName, String groupAvatar, String announcement, String userId) {
        try {
            if (groupId == null || userId == null) {
                return RUtils.fail("群组ID和用户ID不能为空");
            }
            
            // 检查用户是否有权限更新群组信息
            Integer role = chatGroupMemberMapper.getMemberRole(groupId, userId);
            if (role == null || role > 2) { // 只有群主(1)和管理员(2)可以更新群组信息
                return RUtils.fail("您没有权限更新群组信息");
            }
            
            // 更新群组信息
            int updated = chatGroupMapper.updateGroupInfo(groupId, groupName, groupAvatar, announcement);
            
            if (updated > 0) {
                return RUtils.success("更新群组信息成功");
            } else {
                return RUtils.fail("更新群组信息失败");
            }
        } catch (Exception e) {
            log.error("更新群组信息异常", e);
            return RUtils.fail("更新群组信息异常: " + e.getMessage());
        }
    }

    /**
     * 解散群组
     */
    @Override
    @Transactional
    public R dismissChatGroup(String groupId, String userId) {
        try {
            if (groupId == null || userId == null) {
                return RUtils.fail("群组ID和用户ID不能为空");
            }
            
            // 检查用户是否是群主
            Integer role = chatGroupMemberMapper.getMemberRole(groupId, userId);
            if (role == null || role != 1) { // 只有群主可以解散群组
                return RUtils.fail("只有群主可以解散群组");
            }
            
            // 更新群组状态为已解散
            int updated = chatGroupMapper.updateGroupStatus(Long.valueOf(groupId), 0); // 0表示已解散
            
            if (updated > 0) {
                // 批量更新群成员状态
                LambdaQueryWrapper<ChatGroupMember> wrapper = new LambdaQueryWrapper<>();
                wrapper.eq(ChatGroupMember::getGroupId, groupId);
                
                ChatGroupMember updateMember = new ChatGroupMember();
                updateMember.setStatus(0); // 0表示已移除
                
                chatGroupMemberMapper.update(updateMember, wrapper);
                
                return RUtils.success("解散群组成功");
            } else {
                return RUtils.fail("解散群组失败");
            }
        } catch (Exception e) {
            log.error("解散群组异常", e);
            return RUtils.fail("解散群组异常: " + e.getMessage());
        }
    }

    /**
     * 获取用户群组列表
     */
    @Override
    public R getUserChatGroups(String userId) {
        try {
            if (userId == null) {
                return RUtils.fail("用户ID不能为空");
            }
            
            List<ChatGroup> groups = chatGroupMapper.getUserGroups(Long.valueOf(userId));
            return RUtils.success("获取群组列表成功", groups);
        } catch (Exception e) {
            log.error("获取用户群组列表异常", e);
            return RUtils.fail("获取群组列表异常: " + e.getMessage());
        }
    }

    /**
     * 获取群组详情
     */
    @Override
    public R getChatGroupDetail(String groupId) {
        try {
            if (groupId == null) {
                return RUtils.fail("群组ID不能为空");
            }
            
            ChatGroup chatGroup = this.getById(groupId);
            if (chatGroup != null) {
                return RUtils.success("获取群组详情成功", chatGroup);
            } else {
                return RUtils.fail("群组不存在");
            }
        } catch (Exception e) {
            log.error("获取群组详情异常", e);
            return RUtils.fail("获取群组详情异常: " + e.getMessage());
        }
    }

    /**
     * 添加群组成员
     */
    @Override
    @Transactional
    public R addGroupMember(String groupId, String userId, Integer role, String operatorId) {
        try {
            if (groupId == null || userId == null || operatorId == null) {
                return RUtils.fail("参数不能为空");
            }
            
            // 检查操作者权限
            Integer operatorRole = chatGroupMemberMapper.getMemberRole(groupId, operatorId);
            if (operatorRole == null || operatorRole > 2) { // 只有群主和管理员可以添加成员
                return RUtils.fail("您没有权限添加群成员");
            }
            
            // 检查用户是否已经是群成员
            int isMember = chatGroupMemberMapper.checkIsMember(groupId, userId);
            if (isMember > 0) {
                return RUtils.fail("该用户已经是群成员");
            }
            
            // 如果没有指定角色，默认为普通成员
            if (role == null) {
                role = 3; // 3表示普通成员
            }
            
            // 非群主不能添加群主
            if (operatorRole != 1 && role == 1) {
                return RUtils.fail("您没有权限设置群主");
            }
            
            // 添加群成员
            ChatGroupMember member = new ChatGroupMember();
            member.setGroupId(Long.valueOf(groupId));
            member.setUserId(Long.valueOf(userId));
            member.setMemberType(role);
            member.setJoinTime(LocalDateTime.now());
            member.setStatus(1);
            
            int inserted = chatGroupMemberMapper.insert(member);
            
            if (inserted > 0) {
                // 更新群组成员数量
                ChatGroup group = this.getById(groupId);
                group.setCurrentMemberCount(group.getCurrentMemberCount() + 1);
                this.updateById(group);
                
                return RUtils.success("添加群成员成功");
            } else {
                return RUtils.fail("添加群成员失败");
            }
        } catch (Exception e) {
            log.error("添加群组成员异常", e);
            return RUtils.fail("添加群成员异常: " + e.getMessage());
        }
    }

    /**
     * 移除群组成员
     */
    @Override
    @Transactional
    public R removeGroupMember(String groupId, String userId, String operatorId) {
        try {
            if (groupId == null || userId == null || operatorId == null) {
                return RUtils.fail("参数不能为空");
            }
            
            // 检查操作者权限
            Integer operatorRole = chatGroupMemberMapper.getMemberRole(groupId, operatorId);
            if (operatorRole == null || operatorRole > 2) { // 只有群主和管理员可以移除成员
                return RUtils.fail("您没有权限移除群成员");
            }
            
            // 获取被移除用户的角色
            Integer userRole = chatGroupMemberMapper.getMemberRole(groupId, userId);
            if (userRole == null) {
                return RUtils.fail("该用户不是群成员");
            }
            
            // 不能移除群主
            if (userRole == 1) {
                return RUtils.fail("不能移除群主");
            }
            
            // 管理员不能移除其他管理员
            if (operatorRole == 2 && userRole == 2) {
                return RUtils.fail("管理员不能移除其他管理员");
            }
            
            // 查询成员记录
            LambdaQueryWrapper<ChatGroupMember> wrapper = new LambdaQueryWrapper<>();
            wrapper.eq(ChatGroupMember::getGroupId, groupId)
                   .eq(ChatGroupMember::getUserId, userId);
            
            ChatGroupMember member = chatGroupMemberMapper.selectOne(wrapper);
            
            if (member != null) {
                // 更新成员状态为已移除
                int updated = chatGroupMemberMapper.updateMemberStatus(member.getId(), 0);
                
                if (updated > 0) {
                    // 更新群组成员数量
                    ChatGroup group = this.getById(groupId);
                    group.setCurrentMemberCount(group.getCurrentMemberCount() - 1);
                    this.updateById(group);
                    
                    return RUtils.success("移除群成员成功");
                } else {
                    return RUtils.fail("移除群成员失败");
                }
            } else {
                return RUtils.fail("未找到该成员记录");
            }
        } catch (Exception e) {
            log.error("移除群组成员异常", e);
            return RUtils.fail("移除群成员异常: " + e.getMessage());
        }
    }

    /**
     * 更新成员角色
     */
    @Override
    public R updateMemberRole(String groupId, String userId, Integer role, String operatorId) {
        try {
            if (groupId == null || userId == null || role == null || operatorId == null) {
                return RUtils.fail("参数不能为空");
            }
            
            // 检查操作者权限
            Integer operatorRole = chatGroupMemberMapper.getMemberRole(groupId, operatorId);
            if (operatorRole == null || operatorRole != 1) { // 只有群主可以更新成员角色
                return RUtils.fail("只有群主可以更新成员角色");
            }
            
            // 不能更新自己的角色
            if (userId.equals(operatorId)) {
                return RUtils.fail("不能更新自己的角色");
            }
            
            // 更新成员角色
            int updated = chatGroupMemberMapper.updateMemberRole(groupId, userId, role);
            
            if (updated > 0) {
                return RUtils.success("更新成员角色成功");
            } else {
                return RUtils.fail("更新成员角色失败");
            }
        } catch (Exception e) {
            log.error("更新成员角色异常", e);
            return RUtils.fail("更新成员角色异常: " + e.getMessage());
        }
    }

    /**
     * 获取群组成员列表
     */
    @Override
    public R getGroupMembers(String groupId) {
        try {
            if (groupId == null) {
                return RUtils.fail("群组ID不能为空");
            }
            
            List<ChatGroupMember> members = chatGroupMemberMapper.getGroupMembers(Long.valueOf(groupId));
            return RUtils.success("获取群成员列表成功", members);
        } catch (Exception e) {
            log.error("获取群组成员列表异常", e);
            return RUtils.fail("获取群成员列表异常: " + e.getMessage());
        }
    }

    /**
     * 退出群组
     */
    @Override
    @Transactional
    public R quitGroup(String groupId, String userId) {
        try {
            if (groupId == null || userId == null) {
                return RUtils.fail("参数不能为空");
            }
            
            // 获取用户角色
            Integer role = chatGroupMemberMapper.getMemberRole(groupId, userId);
            if (role == null) {
                return RUtils.fail("您不是该群成员");
            }
            
            // 群主不能直接退出群组，需要先转让群主
            if (role == 1) {
                return RUtils.fail("群主不能直接退出群组，请先转让群主");
            }
            
            // 查询成员记录
            LambdaQueryWrapper<ChatGroupMember> wrapper = new LambdaQueryWrapper<>();
            wrapper.eq(ChatGroupMember::getGroupId, groupId)
                   .eq(ChatGroupMember::getUserId, userId);
            
            ChatGroupMember member = chatGroupMemberMapper.selectOne(wrapper);
            
            if (member != null) {
                // 更新成员状态为已退出
                int updated = chatGroupMemberMapper.updateMemberStatus(member.getId(), 0);
                
                if (updated > 0) {
                    // 更新群组成员数量
                    ChatGroup group = this.getById(groupId);
                    group.setCurrentMemberCount(group.getCurrentMemberCount() - 1);
                    this.updateById(group);
                    
                    return RUtils.success("退出群组成功");
                } else {
                    return RUtils.fail("退出群组失败");
                }
            } else {
                return RUtils.fail("未找到该成员记录");
            }
        } catch (Exception e) {
            log.error("退出群组异常", e);
            return RUtils.fail("退出群组异常: " + e.getMessage());
        }
    }
} 